/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package heartinjava;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.net.URL;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JToolBar;

/**
 *
 * @author TIENDAT
 */

public class Play extends KhoiTao {
    
    public JLabel[]                 diemNC;                 // điểm
    public JLabel[]                 nameNC;                 // tên người chơi
    protected ArrayList<JLabel>     arrayCard0;             // play 1
    protected ArrayList<JLabel>     arrayCard1;             // play 2
    protected ArrayList<JLabel>     arrayCard2;             // play 3
    protected ArrayList<JLabel>     arrayCard3;             // play 4
    protected ArrayList<JLabel>     array4Card;             // chứa 4 lá bài đánh ra
    protected JButton               btnXuLyChung;           // button để đổi bài và hiện trái tim
    protected JLabel                note;                   // ghi chú dưới cùng
    protected JLabel                traitim;
    protected Player[]         player;
    protected ArrayList<Integer>    arrayId4Card;           // mãng chứa 4 chỉ số lá bài
    protected int                   clickLaBai = -1;        // =-1 là chưa click vào lá bài
    protected int                   currentTurn = -1;
    protected int                   firstturn = -1;
    protected int                   playState = -1;
    protected boolean               flagDoiBai = false;     // = false là dc đổi bài
    protected boolean               flagDi2Chuong = false;  
    protected boolean               flagChonCo = false;
    protected int                   count13Card = 0;        // đếm 13 là bài để qua ván khác
    protected int                   countSoVanBaiChoi = 0;  // đếm số bàn chơi để cho việc xử lý chia bài
    protected int                   numGame = 1;
    protected ImageIcon             icon = null;            // chứa hình trái tim vỡ           
    protected int                   dem = 0;                // đếm số trái tim vỡ ^^
    
    public Play() {}

    @Override
    public void Update() {}

    @Override
    public void Enter() 
    {
        currentTurn = 0;
        playState = KhaiBao.PLAYSTART;
        
        Color bgColor = new Color(40, 100, 15);
        gui.container.setBackground(bgColor);
        
        btnXuLyChung = new JButton("Đổi bài");
        //btnCommand.setBounds(390, 330, 100, 30);
        btnXuLyChung.setBounds(400, 300, 100, 30);
        btnXuLyChung.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) 
            {
                if (Play.this.playState == KhaiBao.PLAYEXCHANGE) 
                {
                    Play.this.ChapNhanDoiBai();
                } 
                else if (Play.this.playState == KhaiBao.PLAYPLAYING) 
                {
                }
            }
        });
        gui.container.add(btnXuLyChung, 0);
        
        JToolBar status = new JToolBar();
        // tao notice o duoi
        note = new JLabel("♠ ♦ Trợ giúp ♣ ♥");
        note.setForeground(Color.BLUE);
        Font f1 = new Font(Font.DIALOG, Font.BOLD, 16);
        note.setFont(f1);
        
        JPanel pn = new JPanel();
        pn.add(note);
        pn.setBackground(Color.WHITE);
        pn.setBounds(0, 645, KhaiBao.WIDTH, 26);
        gui.container.add(pn,BorderLayout.SOUTH, 0);
        
//        status.add(note);        
//        status.setBounds(0, 645, KhaiBao.WIDTH, 26);
//        gui.container.add(status, BorderLayout.SOUTH,0);
        
        //====trai tim vo
        traitim = new JLabel();
//        URL path = getClass().getResource("resources/heart3.png");
//        icon=new ImageIcon(path);
//        traitim.setIcon(icon);
        traitim.setVisible(false);
//        gui.container.add(traitim,0);
//        traitim.setBounds(0, 20, 125,104);
        //===end
        
        // hien diem so
        Font f = new Font(Font.SANS_SERIF, Font.TRUETYPE_FONT, 20);
        diemNC = new JLabel[4];
        for (int i = 0; i <= 3; i++) 
        {
            diemNC[i] = new JLabel();
            diemNC[i].setFont(f);
            diemNC[i].setForeground(Color.WHITE);
            gui.container.add(diemNC[i], 0);
        }

        diemNC[3].setBounds(808, 140, 150, 30); // trái
        diemNC[2].setBounds(292, 6, 150, 30); // tren cung
        diemNC[1].setBounds(12, 140, 150, 30); // phai
        diemNC[0].setBounds(292, 480, 150, 30); // duoi
        
        diemNC[2].setText("Điểm: " + String.valueOf(player[2].getScore()));
        diemNC[0].setText("Điểm: " + String.valueOf(player[0].getScore()));
        diemNC[3].setText("Điểm: " + String.valueOf(player[3].getScore()));
        diemNC[1].setText("Điểm: " + String.valueOf(player[1].getScore()));
        
        
        gui.repaint();

        arrayCard0 = new ArrayList<JLabel>();
        arrayCard1 = new ArrayList<JLabel>();
        arrayCard2 = new ArrayList<JLabel>();
        arrayCard3 = new ArrayList<JLabel>();
    }

    //--------------------------------------
    //-- chọn 3 lá bài để đổi với người khác
    //--------------------------------------
    protected void ReceiveExchange() 
    {
        if (clickLaBai != -1) 
        { // click vao 1 la bai
            System.out.println("Click to card " + clickLaBai);
            if (player[0].getThreeCard().contains(clickLaBai)) {
                for (int i = 0; i < player[0].getThreeCard().size(); i++) {
                    if (player[0].getThreeCard().get(i) == clickLaBai) {
                        player[0].getThreeCard().remove(i);
                        break;
                    }
                }
                LaBaiChuaDuocChon(clickLaBai);
            } 
            else if (player[0].getThreeCard().size() != 3) 
            {
                player[0].getThreeCard().add(clickLaBai);
                LaBaiDaDuocChon(clickLaBai);
            }
            clickLaBai = -1;
        }

        if (player[0].getThreeCard().size() == 3) 
        {
            showbutton("Đổi bài");
            enableExchange();
        } 
        else 
        {
            disableButton();
        }
    }

    //--------------------------------------
    //-- xử lý việc hiện người chơi nào đánh
    //-- lên Jpanel thông báo
    //--------------------------------------
    protected void nextturn() 
    {
        currentTurn = (currentTurn + 1) % 4;
        System.out.println("Next turn : Wait for player " + (currentTurn + 1) + " play ....");
        if (currentTurn != 0) 
        {
            this.notice("Chờ người " + (currentTurn + 1) + " đánh ...");
        } 
        else 
        {
            this.notice("Đến nước chơi của bạn đó ^ ^ ...");
        }
    }

    //---------------------------------------------------------
    //-- xử lý việc đánh lá bài ra sao
    //-- ban đầu nếu 2 chuồng chưa đi thì cho người giữ đi trước
    //-- sau đó kiểm tra việc đi bài cùng nước và nếu 1 người ko
    //-- còn quân nào ngoài BICH và CO thì cho nó đi
    //----------------------------------------------------------
    protected void ReceiveCardPlay() 
    {
        if (player[0].isContainCard(clickLaBai)) 
        {
            this.notice("♠ ♦ Trợ giúp ♣ ♥");
            if (flagDi2Chuong) 
            {
                if (clickLaBai == KhaiBao.ISTWOCLUBS) 
                {
                    arrayId4Card.add(player[0].danhRaMotLaBai(clickLaBai));
                    hienTatCaLaBaiChay();
                    flagDi2Chuong = false;

                    if (m_Main.getType() == KhaiBao.ISSERVER) 
                    {
                        nextturn();
                        SendDataCardToClient();
                    } 
                    else if (m_Main.getType() == KhaiBao.ISCLIENT) 
                    {
                        SendDataCardToServer();
                    } 
                    else 
                    {
                        nextturn();
                    }
                }
                else 
                {
                    this.notice("Bạn phải đi 2 chuồng đầu tiên !!!");
                }
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                }
            } 
            else if (arrayId4Card.isEmpty()) 
            {
                //-- bat cờ cho nó đi nếu hết quân
                if (player[0].kiemTraCoAndBich()) 
                {
                    flagChonCo = true;
                }
                if ((LaBai.getnuoc_labai(clickLaBai) == KhaiBao.NUOCHEARTS) && (!flagChonCo)) 
                {
                    this.notice("Bạn không được chọn quân Cơ đâu ^^");
                }
                else 
                {
                    if (clickLaBai == KhaiBao.ISSPEADS && (!flagChonCo)) 
                    {
                        this.notice("Bạn không được chọn quân Bích đâu ^^");
                    }
                    else 
                    {
                        arrayId4Card.add(player[0].danhRaMotLaBai(clickLaBai));
                        hienTatCaLaBaiChay();
                        
                        //-- nếu là sever
                        if (m_Main.getType() == KhaiBao.ISSERVER) 
                        {
                            nextturn();
                            SendDataCardToClient();
                        }
                        //--nếu là client
                        else if (m_Main.getType() == KhaiBao.ISCLIENT) 
                        {
                            SendDataCardToServer();
                        }
                        else //-- nếu đánh với computer
                        {
                            nextturn();
                        }
                        try {
                            Thread.sleep(100);
                        } catch (Exception e) {
                        }
                    }
                }
            }
            else if (arrayId4Card.size() > 0) 
            {   
                // server di sau
                if (LaBai.cungNuocCo(clickLaBai, arrayId4Card.get(0)) || (!player[0].kiemTraCungNuocChiSo(arrayId4Card.get(0)))) 
                {
                    arrayId4Card.add(player[0].danhRaMotLaBai(clickLaBai));
                    if (LaBai.getnuoc_labai(clickLaBai) == KhaiBao.NUOCHEARTS) {
                        flagChonCo = true;
                        dem++;
                        if(dem == 1)
                        {
                        this.notice("Trái tim bị vỡ !!!!!");
                        //====trai tim vo
                        //note1 = new JLabel();
//                        traitim.setBounds(0, 20, 125,104);
                        URL path = getClass().getResource("resources/traitim1.png");
                        icon=new ImageIcon(path);
//                        traitim.setIcon(icon);
//                        traitim.setVisible(true);
//                        gui.container.add(traitim,0);
                        btnXuLyChung.setVisible(true);
                        btnXuLyChung.setIcon(icon);
                        this.btnXuLyChung.setBounds(405, 255, 90, 90);
                        btnXuLyChung.setEnabled(true);
                        btnXuLyChung.setBorderPainted(false);
                        btnXuLyChung.setContentAreaFilled(false);
                        btnXuLyChung.setFocusPainted(false);
                        btnXuLyChung.setText(null);
                        //===end
                        }
                        System.out.println("Trái tim bị vỡ !!!!!");
                        System.out.println("dem = " + dem);
                    }
                    hienTatCaLaBaiChay();

                    if (m_Main.getType() == KhaiBao.ISSERVER) 
                    {
                        nextturn();
                        SendDataCardToClient();
                    }
                    else if (m_Main.getType() == KhaiBao.ISCLIENT) 
                    {
                        SendDataCardToServer();
                    }
                    else 
                    {
                        nextturn();
                    }
                } 
                else 
                {
                    this.notice("Bạn phải đi cùng nước!.");
                }
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                }
            } 
            else 
            {
                this.notice("Bạn phải đi cùng chất với lá đầu tiên đánh đó bạn!");
            }
        }
    }

    //----------------------------------------
    //-- hàm này chỉ phục vụ cho client đánh
    //-- reset các quân bài
    //-- đọc dữ liệu nhận dc
    //-- cập nhật lại 4 lá bài cho người chơi
    //----------------------------------------
    protected void CapNhatLaBai(String mess)
    {
        for (int n = 0; n < 4; n++) 
        {
            player[n].getListCard().clear();        
        }
        
        String[] pcard = mess.split("card");
        String[][] mycard = new String[4][];
        for (int i = 1; i < pcard.length; i++) 
        {
            mycard[i - 1] = pcard[i].split("c");
        }
        
        int d = 0;
        for (int j = 0; j < player.length; j++) 
        {
            int thutu = (m_Main.getViTri() + d) % 4;
            if (mycard[thutu] != null) 
            {
                for (int m = 1; m < mycard[thutu].length; m++) 
                {
                    int id = Integer.parseInt(mycard[thutu][m]);
                    player[j].nhanThemLaBai(id);
                }
            }
            d++;
        }
        hienTatCaCacLaBaiKhongChay(); // SUA ADAT
    }

    protected void notice(String st) 
    {
        note.setText(st);
    }

    protected void enableExchange() 
    {
        btnXuLyChung.setEnabled(true);
    }

    protected void disableButton() 
    {
        if (btnXuLyChung != null) 
        {
            btnXuLyChung.setEnabled(false);
        }
    }
    
    //--------------------------
    //-- cập nhật điểm
    //--------------------------
    protected void capNhatDiem() 
    {
        System.out.println("Cập nhật điểm...");
        for (int i = 0; i < 4; i++) 
        {
            diemNC[i].setText("Điểm: " + String.valueOf(player[i].getScore()));
        }
        gui.repaint();
    }

    //----------------------------------------------------------------------
    //-- load all các lá bài
    //----------------------------------------------------------------------
    private ArrayList<JLabel> loadLaBai(Player _player, boolean showcard) 
    {
        ArrayList<JLabel> kq = new ArrayList<JLabel>();
        ImageIcon im;
        URL path;

        for (int i = 0; i < _player.getListCard().size(); i++) 
        {
            if (showcard == true) 
            {
                path = getClass().getResource("resources/" + _player.layChiSoLaBai(i) + ".gif");
            }
            else 
            {
                path = getClass().getResource("resources/0-1.gif");
            }
            im = new ImageIcon(path);
            kq.add(new JLabel(im));
            if (showcard) 
            {
                kq.get(i).setName(String.valueOf(_player.layChiSoLaBai(i)));
                kq.get(i).addMouseListener(new MouseListener() 
                {
                    public void mouseClicked(MouseEvent e) {}
                    public void mousePressed(MouseEvent e) 
                    {
                        clickLaBai = Integer.parseInt(e.getComponent().getName());
                    }
                    public void mouseReleased(MouseEvent e) {}
                    public void mouseEntered(MouseEvent e) {}
                    public void mouseExited(MouseEvent e) {}
                });
            }
        }
        return kq;
    }
    
    //-------------------------------------------------------------
    //-- load 4 lá bài đánh ra
    //-------------------------------------------------------------
    private ArrayList<JLabel> loadLaBai(ArrayList<Integer> fourcard) 
    {
        ArrayList<JLabel> kq = new ArrayList<JLabel>();
        ImageIcon im;
        URL path;
        for (int i = 0; i < fourcard.size(); i++) 
        {
            path = getClass().getResource("resources/" + fourcard.get(i) + ".gif");
            im = new ImageIcon(path);
            kq.add(new JLabel(im));
        }
        return kq;
    }

    //----------------------------------------------------------
    //-- hàm vẽ tất cả các lá bài lên màn hình của 4 người
    //-- case1->case4: hiện các lá bài của các người chơi
    //-- case5: hiện các lá bài đánh ra chính giữa
    //----------------------------------------------------------
    protected void hienLaBaiChay(ArrayList<JLabel> jls, int vitri) 
    {
        final int khoangcach = 20;
        if (!jls.isEmpty()) 
        {
            int x;
            int y;
            switch (vitri) 
            {
                case 1:
                    x = (KhaiBao.WIDTH - khoangcach * 12 - KhaiBao.CARDW) / 2;
                    for (int i = 0; i < jls.size(); i++) 
                    {
                        if (jls.get(i) != null) 
                        {
                            jls.get(i).setBounds(x-118, 518, 73, 97); // thang duoi
                            x += 40;//khoangcach;
                            gui.container.add(jls.get(i), 6);
                        }
                    }
                    break;
                case 2:
                    y = (KhaiBao.HEIGHT - khoangcach * 12 - KhaiBao.CARDH) / 3;
                    for (int i = 0; i < jls.size(); i++) 
                    {
                        if (jls.get(i) != null) 
                        {
                            jls.get(i).setBounds(7, y + 60, 73, 97);
                            y += khoangcach;
                            gui.container.add(jls.get(i), 6);
                        }
                    }
                    break;
                case 3:
                    x = (KhaiBao.WIDTH - khoangcach * 12 - KhaiBao.CARDW) / 2;
                    for (int i = 0; i < jls.size(); i++) 
                    {
                        if (jls.get(i) != null) 
                        {
                            jls.get(i).setBounds(x, 35, 73, 97);
                            x += khoangcach;
                            gui.container.add(jls.get(i), 6);
                        }
                    }
                    break;
                case 4:
                    y = (KhaiBao.HEIGHT - khoangcach * 12 - KhaiBao.CARDH) / 3;
                    for (int i = 0; i < jls.size(); i++) 
                    {
                        if (jls.get(i) != null) 
                        {
                            jls.get(i).setBounds(KhaiBao.WIDTH - KhaiBao.CARDW - 15, y + 60, 73, 97);
                            y += khoangcach;
                            gui.container.add(jls.get(i), 6);
                        }
                    }
                    break;
                case 5:
                    //rip code a dat
                    for (int ii = 0; ii < jls.size(); ii++) 
                    {
                        if(firstturn==0){
                            if(ii==jls.size()-1){
                                try {
                                    if(ii==0){
                                        goBottomCenter(jls, 505);
                                    }else if(ii==1){
                                        goLeftCenter(jls, 20);
                                    } else if(ii==2){
                                        goTopCenter(jls, 30);
                                    } else if(ii==3){
                                        goRightCenter(jls, 802);
                                    }
                                } catch (InterruptedException ex) {
                                    Logger.getLogger(Play.class.getName()).log(Level.SEVERE, null, ex);
                                }
                            }
                            jls.get(ii).setBounds(place((firstturn + ii) % 4));
                            gui.container.add(jls.get(ii), 6);
                        }
                        if(firstturn==1){
                            if(ii==jls.size()-1){
                                try {
                                    if(ii==3){
                                        goBottomCenter(jls, 505);
                                    }else if(ii==0){
                                        goLeftCenter(jls, 20);
                                    } else if(ii==1){
                                        goTopCenter(jls, 30);
                                    } else if(ii==2){
                                        goRightCenter(jls, 802);
                                    }
                                } catch (InterruptedException ex) {
                                    Logger.getLogger(Play.class.getName()).log(Level.SEVERE, null, ex);
                                }
                            }
                            jls.get(ii).setBounds(place((firstturn + ii) % 4));
                            gui.container.add(jls.get(ii), 6);
                        }
                        if(firstturn==2){
                            if(ii==jls.size()-1){
                                try {
                                    if(ii==2){
                                        goBottomCenter(jls, 505);
                                    }else if(ii==3){
                                        goLeftCenter(jls, 20);
                                    } else if(ii==0){
                                        goTopCenter(jls, 30);
                                    } else if(ii==1){
                                        goRightCenter(jls, 802);
                                    }
                                } catch (InterruptedException ex) {
                                    Logger.getLogger(Play.class.getName()).log(Level.SEVERE, null, ex);
                                }
                            }
                            jls.get(ii).setBounds(place((firstturn + ii) % 4));
                            gui.container.add(jls.get(ii), 6);
                        }
                        if(firstturn==3){
                            if(ii==jls.size()-1){
                                try {
                                    if(ii==1){
                                        goBottomCenter(jls, 505);
                                    }else if(ii==2){
                                        goLeftCenter(jls, 20);
                                    } else if(ii==3){
                                        goTopCenter(jls, 30);
                                    } else if(ii==0){
                                        goRightCenter(jls, 802);
                                    }
                                } catch (InterruptedException ex) {
                                    Logger.getLogger(Play.class.getName()).log(Level.SEVERE, null, ex);
                                }
                            }
                            jls.get(ii).setBounds(place((firstturn + ii) % 4));
                            gui.container.add(jls.get(ii), 6);
                        }
                    }
                    break;
            }
        }
    }
    
    //--------------------------------------------------------------
    //-- hàm này phục vụ cho client để khắc phục việc lá bài chạy nhiều lần
    //-- hàm vẽ tất cả các lá bài lên màn hình của 4 người
    //-- case1->case4: hiện các lá bài của các người chơi
    //-- case5: hiện các lá bài đánh ra chính giữa
    //---------------------------------------------------------------
    protected void hienLaBaiKhongChay(ArrayList<JLabel> jls, int vitri) 
    {
        final int khoangcach = 20;
        if (!jls.isEmpty()) 
        {
            int x;
            int y;
            switch (vitri) 
            {
                case 1:
                    x = (KhaiBao.WIDTH - khoangcach * 12 - KhaiBao.CARDW) / 2;
                    for (int i = 0; i < jls.size(); i++) 
                    {
                        if (jls.get(i) != null) 
                        {
                            jls.get(i).setBounds(x-118, 518, 73, 97); // thang duoi
                            x += 40;//khoangcach;
                            gui.container.add(jls.get(i), 6);
                        }
                    }
                    break;
                case 2:
                    y = (KhaiBao.HEIGHT - khoangcach * 12 - KhaiBao.CARDH) / 3;
                    for (int i = 0; i < jls.size(); i++) 
                    {
                        if (jls.get(i) != null) 
                        {
                            jls.get(i).setBounds(7, y + 60, 73, 97);
                            y += khoangcach;
                            gui.container.add(jls.get(i), 6);
                        }
                    }
                    break;
                case 3:
                    x = (KhaiBao.WIDTH - khoangcach * 12 - KhaiBao.CARDW) / 2;
                    for (int i = 0; i < jls.size(); i++) 
                    {
                        if (jls.get(i) != null) 
                        {
                            jls.get(i).setBounds(x, 35, 73, 97);
                            x += khoangcach;
                            gui.container.add(jls.get(i), 6);
                        }
                    }
                    break;
                case 4:
                    y = (KhaiBao.HEIGHT - khoangcach * 12 - KhaiBao.CARDH) / 3;
                    for (int i = 0; i < jls.size(); i++) 
                    {
                        if (jls.get(i) != null) 
                        {
                            jls.get(i).setBounds(KhaiBao.WIDTH - KhaiBao.CARDW - 15, y + 60, 73, 97);
                            y += khoangcach;
                            gui.container.add(jls.get(i), 6);
                        }
                    }
                    break;
                case 5:
                    x = (KhaiBao.WIDTH - khoangcach * arrayId4Card.size() - KhaiBao.CARDW) / 2;
                    for (int i = 0; i < jls.size(); i++) {
                        jls.get(i).setBounds(place((firstturn + i) % 4));
                        x += khoangcach;
                        gui.container.add(jls.get(i), 6);
                    }
                    break;
                    
            }
        }
    }
    //-------------------------------------------------------------------------------------
    //-- rip á đạt
    //-- cho lá bài chạy từ dưới lên
    //-------------------------------------------------------------------------------------
    private void goBottomCenter(ArrayList<JLabel> jls,int chay) throws InterruptedException {
        chay = 505;
        int chay1=0;
        while (chay>350) 
        {                        
            for (int i = 0; i < jls.size(); i++) 
            {
                chay1 = i;
            }
            jls.get(chay1).setBounds(412,chay, 73, 97);
            chay-=25;
            gui.container.add(jls.get(chay1), 6);
            try {
                Thread.sleep(30);
            } catch (Exception e) {
            }
        }
    }
    
    //-------------------------------------------------------------------------------------
    //-- rip á đạt
    //-- cho lá bài chạy từ trái qua
    //-------------------------------------------------------------------------------------
    private void goLeftCenter(ArrayList<JLabel> jls,int chay) throws InterruptedException {
        chay = 20;
        int chay1=0;
        while (chay<295) 
        {                        
            for (int i = 0; i < jls.size(); i++) 
            {
                chay1 = i;
            }
            jls.get(chay1).setBounds(chay,230, 73, 97);
            chay+=25;
            gui.container.add(jls.get(chay1), 6);
            try {
                Thread.sleep(30);
            } catch (Exception e) {}
        }
    }
    
    //-------------------------------------------------------------------------------------
    //-- rip á đạt
    //-- cho lá bài chạy từ trên xuống
    //-------------------------------------------------------------------------------------
    private void goTopCenter(ArrayList<JLabel> jls,int chay) throws InterruptedException {
        chay = 30;
        int chay1=0;
        while (chay<180) 
        {                        
            for (int i = 0; i < jls.size(); i++) 
            {
                chay1 = i;
            }
            jls.get(chay1).setBounds(412,chay, 73, 97);
            chay+=25;
            gui.container.add(jls.get(chay1), 6);
            try {
                Thread.sleep(30);
            } catch (Exception e) {
            }
        }
    }

    //-------------------------------------------------------------------------------------
    //-- rip á đạt
    //-- cho lá bài chạy từ phải qua
    //-------------------------------------------------------------------------------------
    private void goRightCenter(ArrayList<JLabel> jls,int chay) throws InterruptedException {
        chay = 802;
        int chay1=0;
        while (chay>515) 
        {                        
            for (int i = 0; i < jls.size(); i++) 
            {
                chay1 = i;
            }
            jls.get(chay1).setBounds(chay,230, 73, 97);
            chay-=25;
            gui.container.add(jls.get(chay1), 6);
            try {
                Thread.sleep(30);
            } catch (Exception e) {}
        }
    }
        
    //----------------------------------------------------------------
    //-- xóa 4 trụ bài
    //-- edit a dat them dau = de xoa màn hình 1 con bài lỗi cuối cùng
    //----------------------------------------------------------------
    protected void Xoa4TruBai() 
    {
        while (gui.container.getComponentCount() >= 7) 
        {
            gui.container.remove(6);
        }
    }
    
    //----------------------------------------
    //-- cập nhật tất cả các lá bài trên bàn
    //----------------------------------------
    protected void capNhatHienLaBaiChay(int index) 
    {
        switch (index) {
            case 1:
                arrayCard0 = loadLaBai(player[0], true);
                hienLaBaiChay(arrayCard0, 1);
                break;
            case 2:
                arrayCard1 = loadLaBai(player[1], false);
                hienLaBaiChay(arrayCard1, 2);
                break;
            case 3:
                arrayCard2 = loadLaBai(player[2], false);
                hienLaBaiChay(arrayCard2, 3);
                break;
            case 4:
                arrayCard3 = loadLaBai(player[3], false);
                hienLaBaiChay(arrayCard3, 4);
                break;
            case 5:
                array4Card = loadLaBai(arrayId4Card);
                hienLaBaiChay(array4Card, 5);
                break;
        }
    }
    
    //----------------------------------------
    //-- phục vụ cho chơi mạng LAN
    //-- cập nhật tất cả các lá bài trên bàn
    //----------------------------------------
    protected void capNhatHienLaBaiKhongChay(int index) 
    {
        switch (index) {
            case 1:
                arrayCard0 = loadLaBai(player[0], true);
                hienLaBaiKhongChay(arrayCard0, 1);
                break;
            case 2:
                arrayCard1 = loadLaBai(player[1], false);
                hienLaBaiKhongChay(arrayCard1, 2);
                break;
            case 3:
                arrayCard2 = loadLaBai(player[2], false);
                hienLaBaiKhongChay(arrayCard2, 3);
                break;
            case 4:
                arrayCard3 = loadLaBai(player[3], false);
                hienLaBaiKhongChay(arrayCard3, 4);
                break;
            case 5:
                array4Card = loadLaBai(arrayId4Card);
                hienLaBaiKhongChay(array4Card, 5);
                break;
        }
    }

    //-----------------------------
    //-- hiện tất cả lá bài chạy
    //-----------------------------
    public void hienTatCaLaBaiChay() 
    {
        Xoa4TruBai();
        for (int i = 0; i <= 5; i++) 
        {
            capNhatHienLaBaiChay(i);
        }
        gui.repaint();
    }
    
    //------------------------------------
    //-- phuc vụ cho chơi mạng LAN
    //-- hiện tất cả lá bài chạy
    //-------------------------------------
    public void hienTatCaCacLaBaiKhongChay() 
    {
        Xoa4TruBai();
        for (int i = 0; i <= 5; i++) 
        {
            capNhatHienLaBaiKhongChay(i);
        }
        gui.repaint();
    }
    
    //------------------------------------------------
    //-- cho lá bài về vị trí cũ khi nó dc chọn
    //------------------------------------------------
    protected void LaBaiChuaDuocChon(int cardClicked)
    {
        for (int i = 0; i < arrayCard0.size(); i++) 
        {
            if (arrayCard0.get(i).getName().equals(String.valueOf(cardClicked))) 
            {
                arrayCard0.get(i).setBounds(arrayCard0.get(i).getX(),arrayCard0.get(i).getY()+30, arrayCard0.get(i).getWidth(), arrayCard0.get(i).getHeight());
            }
        }
    }

    //------------------------------------------------
    //-- lá bài được chọn: nó trồi lên
    //------------------------------------------------
    protected void LaBaiDaDuocChon(int cardClicked) 
    {
        for (int i = 0; i < arrayCard0.size(); i++) 
        {
            if (arrayCard0.get(i).getName().equals(String.valueOf(cardClicked))) 
            {
                arrayCard0.get(i).setBounds(arrayCard0.get(i).getX(),arrayCard0.get(i).getY()-30, arrayCard0.get(i).getWidth(), arrayCard0.get(i).getHeight());
            }
        }
    }

    //-----------------------------------
    //-- khi chọn button đổi bài
    //-- nếu chơi mạng LAN thì sẽ đợi cho
    //-- các người khác chọn đổi bài....
    //-----------------------------------
    private void ChapNhanDoiBai() 
    {
        flagDoiBai = true;
        this.btnXuLyChung.setText("Vui lòng đợi những game thủ khác...");
        this.btnXuLyChung.setBounds(400, 300, 100, 30);
        disableButton();
        this.btnXuLyChung.setVisible(false);

        //-- khi chơi mạng LAN
        if (m_Main.getType() == KhaiBao.ISCLIENT) 
        {
            String data = "exchange";
            for (int i = 0; i < 3; i++) 
            {
                data += "c";
                data += player[0].getThreeCard().get(i);
            }
            m_Main.getClient().SendDataToServer(data);
        } 
        //-- khi đánh với compiter
        else if (m_Main.getType() == KhaiBao.ISSINGLE) 
        {
            DoExchange();
        }
    }

    //-----------------------------------
    //-- tìm người đầu tiên đi có 2 chuồng
    //-----------------------------------
    protected void TimNguoiDiDauTien() 
    {
        for (int i = 0; i < 4; i++) 
        {
            if (player[i].isContainCard(KhaiBao.ISTWOCLUBS)) 
            {
                firstturn = i;
                currentTurn = firstturn;
                break;
            }
        }
        if (firstturn == 0) 
        {
            flagDi2Chuong = true;
        } else 
        {
            flagDi2Chuong = false;
        }
        System.out.println("Player " + (firstturn + 1) + " play first !!!");

        if (firstturn == 0) 
        {
            this.notice("Đến lượt bạn đi đó bạn ^^ !");
        } else {
            this.notice("Chờ người chơi " + (firstturn + 1) + " đánh trước !!!");
        }
    }
    
    //------------------------------------------
    //-- kết thúc 1 ván bài và cho wa ván khác
    //------------------------------------------
    protected void KetThucMotVanBai() 
    {
        shootTheMoon();
        playState = KhaiBao.PLAYSTART;

        this.notice("Điểm cao gê ta ^^!");
        
        String human = "You:           = " + player[0].getScore();
        String c1 = "\nPlayer 1:   = " + player[1].getScore();
        String c2 = "\nPlayer 2:   = " + player[2].getScore();
        String c3 = "\nPlayer 3:   = " + player[3].getScore();
        String x = human + c1 + c2 + c3;
        
        final JOptionPane jop = new JOptionPane("Notice");
        jop.setBounds(300, 300, 300, 300);
        jop.showMessageDialog(jop,x,"Points of four players!",jop.INFORMATION_MESSAGE,null);
        
        if (KiemTraDu100Diem() == false)
        {
            showbutton("New Round");
            disableButton();
            newRound();
        } 
        else 
        {
            if (m_Main.getType() != KhaiBao.ISCLIENT) 
            {
                showbutton("New Game");
            }
            if (LayDiemMin() == 0) 
            {
                notice("Chúc mừng bạn đã chiến thắng ^^ !!!");
            }
            else 
            {
                notice("Thua rồi bạn ơi o_O !!!");
            }

            for (int i = 0; i < 4; i++) {
                player[i].resetDiem();
            }
        }
        hienTatCaLaBaiChay();
    }

    //------------------------------------------
    //-- kiem tra 100 điểm để cho ra đảo ..^^
    //------------------------------------------
    protected boolean KiemTraDu100Diem() 
    {
        for (int i = 0; i < 4; i++) {
            if (player[i].getScore() >= 100) {
                return true;
            }
        }
        return false;
    }
    
    //------------------------------------------
    //-- lấy số điểm nhỏ nhất .... 
    //------------------------------------------
    protected int LayDiemMin() 
    {
        int min = player[0].getScore();
        int winplayer = 0;
        for (int i = 1; i < 4; i++) 
        {
            if (player[i].getScore() < min) {
                min = player[i].getScore();
                winplayer = i;
            }
        }
        return winplayer;
    }

    protected void showbutton(String string)
    {
        btnXuLyChung.setText(string);
        btnXuLyChung.setEnabled(true);
    }

    protected void shootTheMoon() 
    {
        if (player[0].checkShootTheMoon()) 
        {
            player[1].congDiem(26);
            player[2].congDiem(26);
            player[3].congDiem(26);
        } 
        else 
        {
            for (int i = 1; i < 4; i++) 
            {
                if (player[i].checkShootTheMoon()) 
                {
                    player[0].congDiem(26);
                    for (int j = 0; j < 4; j++) 
                    {
                        if (j != i) {
                            player[j].congDiem(26);
                        }
                    }
                }
            }
        }
    }

    //------------------------------------------
    //-- kiểm tra xem trong 4 lá bài thì lá bài
    //-- nào ăn
    //-- trả ra là chỉ số của lá bài
    //------------------------------------------
    protected int KiemTra4LaBaiWin()
    {
        int max = arrayId4Card.get(0);
        for (int i = 1; i < arrayId4Card.size(); i++) {
            if (LaBai.fisrtThan(arrayId4Card.get(i), max)) {
                max = arrayId4Card.get(i);
            }
        }
        return max;
    }

    //------------------------------------------
    //-- gởi dữ liệu lá bài đánh cho server
    //------------------------------------------
    protected void SendDataCardToClient()
    {
        System.out.println("Sending data to client...");
        // gui du lieu cho cac client
        String data = "";
        for (int i = 0; i < 4; i++) {
            data += "card";
            for (int j = 0; j < player[i].getListCard().size(); j++) {
                data += "c";
                data += this.player[i].layChiSoLaBai(j);
            }
        }
        m_Main.getServer().SendToAllClient(data);

        String fourData = "four";
        for (int i = 0; i < arrayId4Card.size(); i++) {
            fourData += "c";
            fourData += arrayId4Card.get(i);
        }
        m_Main.getServer().SendToAllClient(fourData);
    }

    //----------------------------------------------
    //-- chuyen dữ liệu lá bài chọn sanh sever xử lý
    //---------------------------------------------
    private void SendDataCardToServer()
    {
        System.out.println("Sending data to server...");
        String cardData = "play" + m_Main.getViTri() + "play";
        for (int i = 0; i < player[0].getListCard().size(); i++) {
            cardData += "c";
            cardData += player[0].layChiSoLaBai(i);
        }
        m_Main.getClient().SendDataToServer(cardData);

        String fourData = "four";
        for (int i = 0; i < arrayId4Card.size(); i++) {
            fourData += "c";
            fourData += arrayId4Card.get(i);
        }
        m_Main.getClient().SendDataToServer(fourData);
    }

    protected void DoExchange() 
    {
    }

    private void newRound()
    {
        numGame++;
        for (int i = 0; i < 4; i++) {
            player[i].newRound();
        }
        if ((numGame % 4) == 0) {
            playState = KhaiBao.PLAYPLAYING;
            flagDoiBai = true;
        } else {
            flagDoiBai = false;
        }
        flagDi2Chuong = false;
        flagChonCo = false;
    }

    //------------------------------------------
    //-- xác định 4 vị trí để chứa 4 lá bài đánh
    //------------------------------------------
    private Rectangle place(int player)
    {
        int x = (KhaiBao.WIDTH - KhaiBao.CARDW) / 2;
        switch (player) {
            case 0:
                return new Rectangle(x, 350, 73, 97); // duoi
            case 1:
                return new Rectangle(x - 100, 230, 73, 97);
            case 2:
                return new Rectangle(x, 150, 73, 97); // la tren cung
            case 3:
                return new Rectangle(x + 100, 230, 73, 97);
        }
        return null;
    }
}
